import regionData from './citys'

const ProvinceKeys = [
  '特别行政区',
  '维吾尔自治区',
  '壮族自治区',
  '回族自治区',
  '自治区',
  '省',
  '市',
]

const CityKeys = [
  '布依族苗族自治州',
  '苗族侗族自治州',
  '藏族羌族自治州',
  '哈尼族彝族自治州',
  '壮族苗族自治州',
  '傣族景颇族自治州',
  '蒙古族藏族自治州',
  '傣族自治州',
  '白族自治州',
  '藏族自治州',
  '彝族自治州',
  '回族自治州',
  '蒙古自治州',
  '朝鲜族自治州',
  '地区',
  '哈萨克自治州',
  '盟',
  '市',
]

const DistrictKeys = [
  '满族自治县',
  '满族蒙古族自治县',
  '蒙古族自治县',
  '朝鲜族自治县',
  '回族彝族自治县',
  '彝族回族苗族自治县',
  '彝族苗族自治县',
  '土家族苗族自治县',
  '布依族苗族自治县',
  '苗族布依族自治县',
  '苗族土家族自治县',
  '彝族傣族自治县',
  '傣族彝族自治县',
  '仡佬族苗族自治县',
  '黎族苗族自治县',
  '苗族侗族自治县',
  '哈尼族彝族傣族自治县',
  '哈尼族彝族自治县',
  '彝族哈尼族拉祜族自治县',
  '傣族拉祜族佤族自治县',
  '傣族佤族自治县',
  '拉祜族佤族布朗族傣族自治县',
  '苗族瑶族傣族自治县',
  '彝族回族自治县',
  '独龙族怒族自治县',
  '保安族东乡族撒拉族自治县',
  '回族土族自治县',
  '撒拉族自治县',
  '哈萨克自治县',
  '塔吉克自治县',
  '回族自治县',
  '畲族自治县',
  '土家族自治县',
  '布依族自治县',
  '苗族自治县',
  '瑶族自治县',
  '侗族自治县',
  '水族自治县',
  '傈僳族自治县',
  '仫佬族自治县',
  '毛南族自治县',
  '黎族自治县',
  '羌族自治县',
  '彝族自治县',
  '藏族自治县',
  '纳西族自治县',
  '裕固族自治县',
  '哈萨克族自治县',
  '哈尼族自治县',
  '拉祜族自治县',
  '佤族自治县',
  '达斡尔族区',
  '达斡尔族自治旗',
  '左旗',
  '右旗',
  '中旗',
  '后旗',
  '联合旗',
  '自治旗',
  '旗',
  '自治县',
  '街道办事处',
  '新区',
  '区',
  '县',
  '市',
]

/**
 * 解析输入的地址字符串，提取省、市、区、详细地址等信息。
 * @param {string} inputAddress - 输入的地址字符串。
 * @param {object|number} options - 配置对象或类型，包含以下属性：
 *   - type: 地址解析模式（0表示简化，1表示详细）。
 *   - textFilter: 需要过滤的文本列表。
 *   - nameMaxLength: 地址名称最大长度，默认为4。
 * @returns {object} 返回解析后的地址信息，包括电话、所在省市区、详细地址和姓名。
 */
export function parseAddress(inputAddress, options) {
	// 如果未提供配置，初始化为空对象或默认值
	const config = typeof options === 'object' ? options : {}
	const {
		textFilter = [], nameMaxLength = 4
	} = config

	// 初始化返回的地址数据结构
	let parsedData = {
		name: '',
		tel: '',
		province: undefined,
		city: undefined,
		district: undefined,
		detailAddress: []
	}

	// 处理输入地址并过滤无效文本
	let address = filterText(inputAddress, textFilter)

	// 提取地址和电话
	address = extractTelNumber(address, parsedData) // 修改为 extractTelNumber

	// 拆分地址为多个部分
	let addressParts = address.split(' ').filter(item => item).map(item => item.trim()).filter(item => item.length)
	extractProvinceCityDistrict(addressParts, parsedData)

	// 清理详细地址部分中的省市区名称
	let {
		province: provinceName,
		city: cityName,
		district: districtName,
		detailAddress
	} = parsedData
	
	detailAddress = Array.from(new Set(detailAddress)).filter(item => item.length)

	// 寻找合适的姓名部分并赋值
	if (detailAddress.length > 0) {
		let nameCandidates = spreadArray(detailAddress).filter(item => !!item)
		nameCandidates.sort((a, b) => a.length - b.length)
		let selectedName = ''

		// 根据最大长度筛选姓名
		const nameIndex = nameCandidates.findIndex(candidate => isValidName(candidate, nameMaxLength))
		if (nameIndex !== -1) {
			selectedName = nameCandidates[nameIndex]
		} else if (nameCandidates[0].length <= nameMaxLength && /[\u4E00-\u9FA5]/.test(nameCandidates[0])) {
			selectedName = nameCandidates[0]
		}

		if (selectedName) {
			parsedData.name = selectedName
			detailAddress.splice(detailAddress.findIndex(item => item === selectedName), 1)
		}
	}

	// 清理并返回最终地址数据
	const finalProvince = parsedData.province?.name || ''
	const finalCity = parsedData.city?.name || ''
	const finalDistrict = parsedData.district?.name || ''
	return Object.assign(parsedData, {
		province: finalProvince,
		city: finalCity,
		district: finalDistrict,
		detailAddress: detailAddress.length ? detailAddress.join('') : ''
	})
}

/**
 * 解析地址，获取省市区信息
 */
export function parseAddressRegion(address) {
	const result = {
		province: '',
		city: '',
		district: '',
		detailAddress: []
	}
	extractProvinceCityDistrict([address], result)
	
	return {
		province: result.province?.name || '',
		city: result.city?.name || '',
		district: result.district?.name || '',
		detailAddress: result.detailAddress[0]
	}
}

/**
 * 过滤掉无效文本
 * @param {string} address - 输入的地址
 * @param {Array} textFilter - 需要过滤的文本
 * @returns {string} 过滤后的地址
 */
function filterText(address, textFilter) {
	const filterKeywords = [
		'详细地址', '收货地址', '收件地址', '地址', '所在地区', '地区', '姓名', '收货人', '收件人', '联系人', '收',
		'邮编', '联系电话', '电话', '联系人手机号码', '手机号码', '手机号', '自治区直辖县级行政区划', '省直辖县级行政区划'
	].concat(textFilter)

	filterKeywords.forEach(keyword => {
		address = address.replace(new RegExp(keyword, 'g'), ' ')
	})

	const specialChars = /[`~!@#$^&*()=|{}':;',\[\].<>/?~！@#￥……&*（）——|{}【】‘；：”“’。，、？]/g
	return address.replace(specialChars, ' ').replace(/ {2,}/g, ' ')
}

/**
 * 提取地址中的电话号码
 * @param {string} address - 输入的地址
 * @returns {Object} 返回处理后的地址和电话号码
 */
function extractTelNumber(address, parsedData) { // 修改为 extractTelNumber
	let tel = '' // 修改为 tel
	const telRegex = /(\d{7,12})|(\d{3,4}-\d{6,8})|(86-[1][0-9]{10})|(86[1][0-9]{10})|([1][0-9]{10})/g
	const match = telRegex.exec(address) // 修改为 telRegex
	if (match) {
		parsedData.tel = match[0] // 修改为 tel
		address = address.replace(parsedData.tel, ' ') // 修改为 tel
	}
	return address
}

/**
 * 提取地址中的电话号码
 * @param {string} address - 输入的地址
 * @returns {Object} 返回处理后的地址和省市区
 */
function extractProvinceCityDistrict(addressParts, parsedData) {
	for(let idx in addressParts) {
		let part = addressParts[idx]
		if(!part) {
			continue
		}
		if (parsedData.province && parsedData.city && parsedData.district) {
			parsedData.detailAddress.push(part)
		} else {
			handleDetailedAddress(part, parsedData.city?.children || parsedData.province?.children || regionData, parsedData)
		}
	}
}
/**
 * 处理详细地址
 * @param {string} part - 地址部分
 * @param {Object} parsedData - 已解析的地址数据
 * @returns {Object} 处理后的地址数据
 */
function handleDetailedAddress(address, regionData, parsedData) {
		
	// 递归查找省市区
	function findRegion(data, namePart) {
	    for (let item of data) {
	        if (namePart.startsWith(item.name)) {
	            return item;
	        }
	    }
	    return null;
	}
	// 1. 查找省
	if(!parsedData.province) {
		let provinceMatch = findRegion(regionData, address);
		if(provinceMatch) {
			parsedData.province = provinceMatch;
			address = address.replace(provinceMatch.name, '').trim();
			ProvinceKeys.forEach(v => {
				if(address.startsWith(v)) {
					address = address.replace(v, '');
				}
			})
			if(address) {
				return handleDetailedAddress(address, provinceMatch.children, parsedData)
			}
		}
	} else if(!parsedData.city) {
		if(!(['北京', '上海', '重庆', '天津'].includes(parsedData.province.name))) {
			// 2. 查找市
			let cityMatch = findRegion(regionData, address);
			if (cityMatch) {
			    parsedData.city = cityMatch;
			    address = address.replace(cityMatch.name, '').trim();
				CityKeys.forEach(v => {
					if(address.startsWith(v)) {
						address = address.replace(v, '');
					}
				})
				if(address) {
					return handleDetailedAddress(address, cityMatch.children, parsedData)
				}
			}
		} else {
			parsedData.city = parsedData.province.children[0]
			address = address.replace(parsedData.city.name, '').trim();
			if(address) {
				return handleDetailedAddress(address, parsedData.city.children, parsedData)
			}
		}
	} else if(!parsedData.district) {
		let districtMatch = findRegion(regionData, address);
		if (districtMatch) {
		    parsedData.district = districtMatch;
		    address = address.replace(districtMatch.name, '').trim();
			// DistrictKeys.forEach(v => {
			// 	if(address.startsWith(v)) {
			// 		address = address.replace(v, '');
			// 	}
			// })
		}
	}
	// 4. 剩余的部分为详细地址
	if (address) {
		if(!parsedData.detailAddress)  parsedData.detailAddress = []
		parsedData.detailAddress.push(address);
	}
}

/**
 * 检查地址是否符合姓名最大长度的规则
 * @param {string} name - 地址中的部分
 * @param {number} maxLength - 姓名最大长度
 * @returns {boolean} 是否符合规则
 */
function isValidName(name, maxLength) {
	// return name.length <= maxLength && /[\u4E00-\u9FA5]/.test(name)
	const regex = /^([\u4e00-\u9fa5]{1,4})$|^[A-Z][a-z]+(\s[A-Z][a-z]+)*$/;
	return regex.test(name);
}

/**
 * 展开数组或对象
 * @param {Array|Object} e - 输入的数据
 * @returns {Array} 展开的数组
 */
function spreadArray(e) {
	if (Array.isArray(e)) return e
	if (typeof e[Symbol.iterator] === 'function') return Array.from(e)
	if (e && typeof e === 'object') return Object.values(e)
	throw new TypeError('Invalid attempt to spread non-iterable instance.')
}

export function completeProvince(input) {
	if(!input) return input
	const suffixes = {
		"北京": "市",
		"天津": "市",
		"上海": "市",
		"重庆": "市",
		"新疆": "维吾尔自治区",
		"西藏": "自治区",
		"内蒙古": "自治区",
		"宁夏": "回族自治区",
		"广西": "壮族自治区",
		"香港": "特别行政区",
		"澳门": "特别行政区",
	};

	if (suffixes[input]) {
		return input + suffixes[input];
	}

	if (ProvinceKeys.some(v => input.endsWith(v))) {
		return input; // 已经包含完整后缀的情况
	}

	return input + "省";
}

export function completeCity(input) {
	if(!input) return input
	if (CityKeys.some(v => input.endsWith(v))) {
		return input; // 已经包含完整后缀的情况
	}

	return input + "市";
}

export default {
	completeProvince,   // 补全省份 ，如 福建 -》 福建省， 北京 -》 北京市
	completeCity,  // 补全市区 ，如 福州 -》 福州市， 北京 -》 北京市
	parse: parseAddress,  // 从收货地址解析 联系人、电话、省市区、详细地址
	parseRegion: parseAddressRegion  // 从地址信息中解析省市区、详细地址
}